﻿// See https://aka.ms/new-console-template for more information
//中介者模式是一种行为型设计模式，他通过封装一系列对象之间的交互方式来降低对象之间的耦合度，让这些对象更加独立地协同工作。
//在中介者模式中，通过引入一个中介者对象，将系统中的各个对象之间的交互行为转移给中介者对象来处理，从而实现各个对象之间的解耦。中介者对象充当了一个调解者的角色，负责协调各个对象之间的交互行为。
//在QQ聊天中，存在两种聊天方式，一种是两个用户之间直接进行聊天，另一种是将所有相关用户放在一个QQ群中，我们在群中聊天。在QQ聊天软件中，用户与用户之间存在多对多关系，这导致系统中用户之间的关系形成了复杂的关系网，如果没有QQ群，一个用户想要将相同的信息发送给其他用户就需要一个一个的发，但如果我们将所有需要接受这条信息的用户拉到一个QQ群中，用户只需要和QQ群一个对象交互即可。群会将发送者的信息转发给每一个接收者。通过引入QQ群，将极大地减少系统中用户之间的两两通讯。

//在软件开发中，如果每些类或者对象之间互相调用的关系错综复杂，类似QQ中用户之间的关系，我们就可以引用一个类似QQ群的中介类来协调这些类或者对象，以降低系统的耦合度。中介者模式为此诞生。通过引入中介者，原本的对象之间的多对多关系可以简化为一对多关系。

//中介者模式中的核心角色有
//·抽象中介者（Mediator）：定义了中介者对象的接口，提供了各个同事对象之间通信的方法
//·具体中介者（ConcreteMediator）：实现了抽象中介者定义的接口，复杂协调各个同时对象之间的通信。
//·抽象同事类（Colleague）：定义了同时对象的接口，包括注册中介者，发送消息等方法。
//·具体同事类（ConcreteColleague）：实现了抽象同时类定义的接口，与其他同事类进行交互时，需要通过中介者对象来完成。




using static 中介者模式.Example2;

//Mediator mediator=new TemperatureController();
//Bedroom bedroom=new Bedroom(mediator);
//Livingroom livingroom=new Livingroom(mediator);

//mediator.Register(bedroom);
//mediator.Register(livingroom);

//bedroom.SetTemperature(20);
//livingroom.SetTemperature(30);

//bedroom.AdjustTemperature();
//livingroom.AdjustTemperature();

ChatRoom chatRoom = new ChatRoomImpl();

User user1 = new ConcreteUser("Alice", chatRoom);
User user2 = new ConcreteUser("Bob", chatRoom);
User user3 = new ConcreteUser("Charlie", chatRoom);

chatRoom.AddUser(user1);
chatRoom.AddUser(user2);
chatRoom.AddUser(user3);

user1.SendMessage("Hello, everyone!");
user2.SendMessage("Hi, Alice!");
user3.SendMessage("Hey, Bob!");

chatRoom.RemoveUser(user3);

user1.SendMessage("Goodbye, Charlie!");
user2.SendMessage("See you later, Alice!");






Console.WriteLine("Hello, World!");

//假设一个场景是一个包含多个房间的房子，每个房间有一个温度传感器和一个温度控制器，中介者对象是一个温度调节器，他复杂协调各个房间之间的温度调节，以保证整个房子的温度平衡。
//抽象中介者类，温度调节器
public abstract class Mediator
{
    //注册房间
    public abstract void Register(Room room);

    //调节温度
    public abstract void AdjustTemperature(Room sender);
}
//具体中介者类，具体的温度调节器
public class TemperatureController : Mediator
{
    private List<Room> _rooms;
    public override void Register(Room room)
    {
        if (_rooms == null)
        {
            _rooms= new List<Room>();
            _rooms.Add(room);
        }
        else
        {
            _rooms.Add(room);
        }
    }
    public override void AdjustTemperature(Room sender)
    {
        float totalTemperature = 0;
        foreach(var room in _rooms)
        {
            if (room != sender)
            {
                totalTemperature+= room.Temperature;
            }
        }
        float averageTemperature=totalTemperature/(_rooms.Count-1);
        if (Math.Abs(sender.Temperature - averageTemperature) > 0.01f)
        {
            sender.SetTemperature(averageTemperature);
        }
    }
}

//抽象同时类，房间
public abstract class Room
{
    protected Mediator mediator;
    protected float temperature;

    public Room(Mediator mediator)
    {
        this.mediator = mediator;
    }

    public abstract void AdjustTemperature();

    public abstract void SetTemperature(float temperature);

    public float Temperature
    {
        get { return temperature; }
    }
}

//具体同时类，具体房间，卧室
public class Bedroom : Room
{
    public Bedroom(Mediator mediator) : base(mediator)
    {
    }
    public override void AdjustTemperature()
    {
        mediator.AdjustTemperature(this);
    }
    public override void SetTemperature(float temperature)
    {
        this.temperature = temperature;
        Console.WriteLine("卧室的温度已经调整为："+temperature);
    }
}

//具体同时类，具体房间，客厅
public class Livingroom : Room
{
    public Livingroom(Mediator mediator) : base(mediator)
    {
    }
    public override void AdjustTemperature()
    {
        mediator.AdjustTemperature(this);
    }
    public override void SetTemperature(float temperature)
    {
        this.temperature = temperature;
        Console.WriteLine("客厅的温度已经调整为：" + temperature);
    }
}